/********************************************************************************
* @author: Liu  HZ
* @date: 2024/5/25
* @description: 
********************************************************************************/

#include <iostream>
#include <memory>

using namespace std;

struct A {
    A(int i) {
        cout << i << endl;
    }

    A(double d, int i) {
        cout << d << " " << i << endl;
    }

    A(float f, int i, const char *c) {
        cout << f << " " << i << endl;
    }
    //...等等系列的构造函数版本
};

struct B : A {
    using A::A;
    //关于基类各构造函数的继承一句话搞定
    //......
};

void test_auto();

class Foo {
    unique_ptr<A> member;

public:
    Foo(unique_ptr<A> &&parameter)
            : member(std::move(parameter))   // error
    {}
};

struct AA {
    AA(int value) {   // 没有explicit关键字
        cout << "value" << endl;
    }
};

union U {
    A a; // 非POD类型 c++11之前不可以这样定义联合体
    int b;
};

void PrintV(int &t) {
    cout << "lvalue" << endl;
}

void PrintV(int &&t) {
    cout << "rvalue" << endl;
}

template<typename T>
void Test(T &&t) {
    PrintV(t);
    PrintV(std::forward<T>(t));

    PrintV(std::move(t));
}

int main() {
//    AA a = 1; // 可以隐式转换
//
//    cout << typeid(AA).name() << endl;

    Test(1);                // lvalue rvalue rvalue
    int a = 1;
    Test(a);                // lvalue lvalue rvalue
    Test(std::forward<int>(a));         // lvalue rvalue rvalue
    Test(std::forward<int &>(a));         // lvalue lvalue rvalue
    Test(std::forward<int &&>(a));         // lvalue rvalue rvalue

    return 0;
}

void test_auto() {
    auto i = 5;

    int arr[10] = {0};
    auto auto_arr = arr;
    auto &auto_arr2 = arr;

    for (int j: arr) {
        cout << j << " ";
    }


    auto_arr2[1] = 10;

    cout << arr[1] << endl;

    auto x = 1;
    auto y = 2;
    decltype(x + y) z;
}
